生如夏花，开到颓靡。

主要功能

namedtuple(): 生成可以使用名字来访问元素内容的tuple子类
deque: 双端队列，可以快速的从另外一侧追加和推出对象
Counter: 计数器，主要用来计数
OrderedDict: 有序字典
defaultdict: 带有默认值的字典
ChainMap：这是一个为多个映射创建单一视图的类字典类型，也就是说，它同样具有字典类型的方法，它比基础数据结构中的字典的创建和多次更新要快，需要注意的是，增删改的操作都只会针对该对象的第一个字典，其余字典不会发生改变，但是如果是查找，则会在多个字典中查找，直到找到第一个出现的key为止。

namedtuple()

namedtuple主要用来产生可以使用名称来访问元素的数据对象，通常用来增强代码的可读性，在访问一些tuple类型的数据时尤其好用。
例子1：

import collections

coordinate = collections.namedtuple('Coordinate', ['x', 'y'])
co = coordinate(10,20)
print(type(co))
print(co)
print(co.x, co.y)
print(co[0], co[1])
co = coordinate._make([100, 200])
print(co)
print(co.x, co.y)
co = co._replace(x=30)
print(co)
print(co.x, co.y)
运行：

<class '__main__.Coordinate'>
Coordinate(x=10, y=20)
10 20
10 20
Coordinate(x=100, y=200)
100 200
Coordinate(x=30, y=200)
30 200

例子2：

websites = [
    ('Sohu', 'http://www.sohu.com/', u'张朝阳'),
    ('Sina', 'http://www.sina.com.cn/', u'王志东'),
    ('163', 'http://www.163.com/', u'丁磊')
]

Website = collections.namedtuple('Website', ['name', 'url', 'founder'])

for website in websites:
    website = Website._make(website)
    print(website)
运行：

Website(name='Sohu', url='http://www.sohu.com/', founder='张朝阳')
Website(name='Sina', url='http://www.sina.com.cn/', founder='王志东')
Website(name='163', url='http://www.163.com/', founder='丁磊')

例子3（一摞有序的纸牌）：

import collections
Card = collections.namedtuple('Card', ['rank', 'suit'])


class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

beer_card = Card('7', 'diamonds')
print(beer_card)

deck = FrenchDeck()
print(len(deck))

print(deck._cards)
print(deck[0])
print(deck[-1])

from random import choice
print(choice(deck))

print(deck[:3])
print(deck[12::13])     # 先抽出索引是 12 的那张牌，然后每隔 13 张牌拿 1 张

for card in deck:
    print(card)

for card in reversed(deck):
    print(card)

deque()

deque其实是 double-ended queue 的缩写，翻译过来就是双端队列，它最大的好处就是实现了从队列头部快速增加和取出对象: .popleft(), .appendleft() 。
原生的list也可以从头部添加和取出对象？就像这样：

l.insert(0, v)
l.pop(0)

但是值得注意的是，list对象的这两种用法的时间复杂度是 O(n) ，也就是说随着元素数量的增加耗时呈线性上升。而使用deque对象则是 O(1) 的复杂度，所以当你的代码有这样的需求的时候，一定要记得使用deque。

作为一个双端队列，deque还提供了一些其他的好用方法，比如 rotate 等。

例子：

# -*- coding: utf-8 -*-
"""
下面这个是一个有趣的例子，主要使用了deque的rotate方法来实现了一个无限循环
的加载动画
"""
import sys
import time
from collections import deque

fancy_loading = deque('>--------------------')

while True:
    print '\r%s' % ''.join(fancy_loading),
    fancy_loading.rotate(1)
    sys.stdout.flush()
    time.sleep(0.08)
运行:

# 一个无尽循环的跑马灯
------------->-------

Counter()

计数器是一个非常常用的功能需求，collections也贴心的为你提供了这个功能。

例子：

# -*- coding: utf-8 -*-
"""
下面这个例子就是使用Counter模块统计一段句子里面所有字符出现次数
"""
from collections import Counter

s = '''A Counter is a dict subclass for counting hashable objects. It is an unordered collection where elements are stored as dictionary keys and their counts are stored as dictionary values. Counts are allowed to be any integer value including zero or negative counts. The Counter class is similar to bags or multisets in other languages.'''.lower()

c = Counter(s)
# 获取出现频率最高的5个字符
print c.most_common(5)
运行:

[(' ', 54), ('e', 32), ('s', 25), ('a', 24), ('t', 24)]

OrderedDict()

在Python中，dict这个数据结构由于hash的特性，是无序的，这在有的时候会给我们带来一些麻烦，幸运的是，collections模块为我们提供了OrderedDict，当你要获得一个有序的字典对象时，用它就对了。

例子：

# -*- coding: utf-8 -*-
from collections import OrderedDict

items = (
    ('A', 1),
    ('B', 2),
    ('C', 3)
)

regular_dict = dict(items)
ordered_dict = OrderedDict(items)

print 'Regular Dict:'
for k, v in regular_dict.items():
    print k, v

print 'Ordered Dict:'
for k, v in ordered_dict.items():
    print k, v
运行:

Regular Dict:
A 1
C 3
B 2
Ordered Dict:
A 1
B 2
C 3

defaultdict()

我们都知道，在使用Python原生的数据结构dict的时候，如果用 d[key] 这样的方式访问，当指定的key不存在时，是会抛出KeyError异常的。

但是，如果使用defaultdict，只要你传入一个默认的工厂方法，那么请求一个不存在的key时，便会调用这个工厂方法使用其结果来作为这个key的默认值。

# -*- coding: utf-8 -*-
from collections import defaultdict

members = [
    # Age, name
    ['male', 'John'],
    ['male', 'Jack'],
    ['female', 'Lily'],
    ['male', 'Pony'],
    ['female', 'Lucy'],
]

result = defaultdict(list)
for sex, name in members:
    result[sex].append(name)

print result
运行:

defaultdict(<type 'list'>, {'male': ['John', 'Jack', 'Pony'], 'female': ['Lily', 'Lucy']})

ChainMap()

适用于以下情况

多个字典；
允许key是重复；
总是访问最高优先级字典中的关键字；
不需要改变key对应的value；
字典频繁的创建和更新已经造成巨大的性能问题，希望改善性能问题；

举个例子

import collections
a = {1: 2, 2: 3}
b = {1: 3, 3: 4, 4: 5}
chains = collections.ChainMap(a, b)
# maps
# 注意maps是个属性，不是一个方法，其改变
print(chains.maps)  # [{1: 2, 2: 3}, {1: 3, 3: 4, 4: 5}]
# get
assert chains.get(1, -1) == 2
# parents
# 从第二个map开始找
assert chains.parents.get(1, -1) == 3
# popitem
assert chains.popitem() == (2, 3)
# pop
# 返回的是value
assert chains.pop(1) == 2
# new_child
assert chains.new_child()
print(chains.maps)  # [{}, {1: 3, 3: 4, 4: 5}]
chains[2] = 1
print(chains.maps)  # [{2: 1}, {1: 3, 3: 4, 4: 5}]
# setdedault
# 如果已经存在key，则不会添加
assert chains.setdefault(1, 10) == 3
# update
chains.update({2: 4, 3: 5})
print(chains.maps)  # [{1: 2, 2: 4, 3: 5}, {1: 3, 3: 4, 4: 5}]
# keys
print(chains.keys())  # KeysView(ChainMap({2: 4, 3: 5}, {1: 3, 3: 4, 4: 5}))
# KeysView 继承了mapping和set
print(2 in chains.keys())  # True
print(len(chains.keys()))  # 4（重复的不算）
# clear
chains.clear()
print(chains.maps)  # [{}, {1: 3, 3: 4, 4: 5}]

要注意的是还有他的特殊用法

maps    返回全部的字典（这个列表中至少存在一个列表）
new_child    在字典列表头部插入字典，如果其参数为空，则会默认插入一个空字典，并且返回一个改变后的ChainMap对象
parents    返回除了第一个字典的其余字典列表的ChainMap对象，可以用来查询除了第一个列表以外的内容。